Interpreter Sniffing by Friends of I7

Version 1/140209 of Interpreter Sniffing (for Glulx only) by Friends of I7 begins here.

"Phrases for testing, as far as is possible, which interpreter the story is running under."

"with contributions by Dannii Willis and Brady Garvin"



Book "Kinds for Describing Interpreters"

Chapter "Glulx Implementations"

A Glulx implementation is a kind of value.
Unknown Glulx implementation is a Glulx implementation.

Chapter "IO Implementations"

An IO implementation is a kind of value.
Unknown Glk implementation and Unknown non-Glk implementation are IO implementations.

Chapter "Interpreters"

An interpreter is a kind of value.
Unknown interpreter is an interpreter.

Chapter "Version Numbers"

A version number is a kind of value.
65535.255.255 specifies a version number.

Section "Support Phrases for Saying Version Numbers without Leading Zeros" (unindexed)

Include (-
   [ is_logicalRightShift value distance;
     @ushiftr value distance sp;
     @return sp;
   ];
-).

To decide what number is the bitwise and of (I - an arithmetic value) and (J - a number): (- ({I} & {J}) -).
To decide what number is (I - an arithmetic value) logically shifted (D - a number) bit/bits right: (- is_logicalRightShift({I}, {D}) -).

Section "Saying Version Numbers without Leading Zeros"

[This override does not affect showmes, but extra zeros in debugging output give no great harm.]

To say (N - a version number):
   let the major version number be N logically shifted 16 bits right;
   let the minor version number be the bitwise and of N logically shifted 8 bits right and 255;
   let the patch level be the bitwise and of N and 255;
   say "[the major version number].[no line break][the minor version number].[no line break][the patch level]".

Book "Framework for Detecting Interpreters"

Chapter "Workarounds" (unindexed)

[For Inform bug 759.]
To consider (R - a nothing based rule): (- FollowRulebook({R}); -).
To decide what K is the (name of kind K) produced by (R - a nothing based rule producing a value of kind K): (- ResultOfRule({R}, 0, true, {-strong-kind:K}) -).

Chapter "Responding to Restores" (unindexed)

[A player can save a story under one interpreter and restore under another; we need to resniff (and possibly notify the story) after any restore.]

The resniffing rulebook is a nothing based rulebook.
The when the interpreter changes rulebook is a nothing based rulebook.

To resniff the interpreter after a restore (this is resniffing the interpreter after a restore):
   consider the resniffing rulebook;
   let the old result of Glulx implementation detection be a Glulx implementation;
   let the new result of Glulx implementation detection be a Glulx implementation;
   let the old result of IO implementation detection be an IO implementation;
   let the new result of IO implementation detection be an IO implementation;
   if Glulx implementation already detected is true:
     now the old result of Glulx implementation detection is the cached result of Glulx implementation detection;
     now Glulx implementation already detected is false;
     now the new result of Glulx implementation detection is the current Glulx implementation;
   if IO implementation already detected is true:
     now the old result of IO implementation detection is the cached result of IO implementation detection;
     now IO implementation already detected is false;
     now the new result of IO implementation detection is the current IO implementation;
   unless the old result of Glulx implementation detection is the new result of Glulx implementation detection and the old result of IO implementation detection is the new result of IO implementation detection:
     consider the when the interpreter changes rulebook.

Section "Initial Resniffing" (unindexed)

This is the resniffing stage rule:
   consider the resniffing rulebook.
The resniffing stage rule is listed before the virtual machine startup rule in the startup rulebook.

Section "Injection of Post-Restore Resniffing" (unindexed)

Include (-
   [ SAVE_THE_GAME_R res fref;
     if (actor ~= player) rfalse;
     fref = glk_fileref_create_by_prompt($01, $01, 0);
     if (fref == 0) jump SFailed;
     gg_savestr = glk_stream_open_file(fref, $01, GG_SAVESTR_ROCK);
     glk_fileref_destroy(fref);
     if (gg_savestr == 0) jump SFailed;
     @save gg_savestr res;
     if (res == -1) {
       ! The player actually just typed "restore". We're going to print
       ! GL__M(##Restore,2); the Z-Code Inform library does this correctly
       ! now. But first, we have to recover all the Glk objects; the values
       ! in our global variables are all wrong.
       ((+ resniffing the interpreter after a restore +)-->1)();
       GGRecoverObjects();
       glk_stream_close(gg_savestr, 0); ! stream_close
       gg_savestr = 0;
       RESTORE_THE_GAME_RM('B'); new_line;
       rtrue;
     }
     glk_stream_close(gg_savestr, 0); ! stream_close
     gg_savestr = 0;
     if (res == 0) { SAVE_THE_GAME_RM('B'); new_line; rtrue; }
     .SFailed;
     SAVE_THE_GAME_RM('A'); new_line;
   ];
-) instead of "Save The Game Rule" in "Glulx.i6t".

Chapter "Detecting Glulx Implementations"

Section "Cached Glulx Implementation Detection" (unindexed)

Glulx implementation already detected is a truth state that varies. Glulx implementation already detected is false.
The cached result of Glulx implementation detection is a Glulx implementation that varies.

Chapter "Rulebook and Phrase for Detecting Glulx Implementations"

The Glulx implementation detection rulebook is a nothing based rulebook producing a Glulx implementation.

To decide what Glulx implementation is the current Glulx implementation:
   if Glulx implementation already detected is false:
     now the cached result of Glulx implementation detection is the Glulx implementation produced by the Glulx implementation detection rulebook;
     unless the rule succeeded:
       now the cached result of Glulx implementation detection is Unknown Glulx implementation;
     now Glulx implementation already detected is true;
   decide on the cached result of Glulx implementation detection.

Chapter "Detecting Glulx Versions"

Include (-
   [ is_glulxVersion;
     @gestalt 0 0 sp;
     @return sp;
   ];
-).

To decide what version number is the current Glulx version number: (- is_glulxVersion() -).

Chapter "Detecting IO Implementations"

Section "Cached IO Implementation Detection" (unindexed)

IO implementation already detected is a truth state that varies. IO implementation already detected is false.
The cached result of IO implementation detection is an IO implementation that varies.

Section "Glk Test" (unindexed)

Include (-
   [ is_Glk;
     @gestalt 4 2 sp;
     @return sp;
   ];
-).
To decide whether the Glk gestalt is set: (- is_Glk() -).

Chapter "Rulebook and Phrase for Detecting IO Implementations"

The IO implementation detection rulebook is a nothing based rulebook producing an IO implementation.

To decide what IO implementation is the current IO implementation:
   if IO implementation already detected is false:
     now the cached result of IO implementation detection is the IO implementation produced by the IO implementation detection rulebook;
     unless the rule succeeded:
       if the Glk gestalt is set:
         now the cached result of IO implementation detection is Unknown Glk implementation;
       otherwise:
         now the cached result of IO implementation detection is Unknown non-Glk implementation;
     now IO implementation already detected is true;
   decide on the cached result of IO implementation detection.

Chapter "Detecting IO Versions"

Include (-
   [ is_ioVersion
     canGetVersion;
     @gestalt 4 2 canGetVersion;
     if (~~canGetVersion) {
       return 0;
     }
     return glk_gestalt(gestalt_Version, 0);
   ];
-).

To decide what version number is the current IO version number: (- is_ioVersion() -).

Chapter "Detecting Interpreter Versions"

Include (-
   [ is_interpreterVersion;
     @gestalt 1 0 sp;
     @return sp;
   ];
-).

To decide what version number is the current interpreter version number: (- is_interpreterVersion() -).

Book "Glulx Implementation Tests"

Chapter "Git/Gift"

Git/Gift Glulx is a Glulx implementation.

Section "Git/Gift Test" (unindexed)

Include (-
   [ is_GitGift;
     @gestalt 31040 0 sp;
     @return sp;
   ];
-).
To decide whether the Git gestalt is set: (- is_GitGift() -).

Section "Git/Gift Rule" (unindexed)

Glulx implementation detection (this is the test for Git/Gift rule):
   if the Git gestalt is set:
     rule succeeds with result Git/Gift Glulx.

Chapter "FyreVM"

FyreVM Glulx is a Glulx implementation.

Section "FyreVM Test" (unindexed)

Include (-
   [ is_FyreVM;
     @gestalt 4 20 sp;
     @return sp;
   ];
-).
To decide whether the FyreVM gestalt is set: (- is_FyreVM() -).

Section "FyreVM Rule" (unindexed)

Glulx implementation detection (this is the test for FyreVM rule):
   if the FyreVM gestalt is set:
     rule succeeds with result FyreVM Glulx.

Book "IO Implementation Tests"

Chapter "FyreVM Channel System"

The FyreVM channel system is an IO implementation.

Section "FyreVM Channel System Test" (unindexed)

[See Section "FyreVM Test" above.]

Section "FyreVM Channel System Rule" (unindexed)

IO implementation detection (this is the test for the FyreVM channel system rule):
   if the FyreVM gestalt is set:
     rule succeeds with result FyreVM channel system.

Chapter "CocoaGlk"

CocoaGlk is an IO implementation.

Section "CocoaGlk Test" (unindexed)

The CocoaGlk detection flag is a truth state that varies. the CocoaGlk detection flag is false.

Include (-
   Array is_cocoaMethodCheck --> 1;
   Array is_cocoaSizeCheck --> 1;
   Array is_cocoaKeyWindowCheck --> 1;
   [ is_detectCocoaGlk
     glkSupported root nonroot firstWindow secondWindow;
     ! Detect CocoaGlk via Inform bug 819, without falling afoul of Inform bug 961.
     (+ CocoaGlk detection flag +) = false;
     ! If there is no Glk, there is obviously no CocoaGlk, so rule out that case first.
     @gestalt 4 2 glkSupported;
     if (~~glkSupported) {
       rfalse;
     }
     ! Now, to identify bug 819 we need two related windows whose circumstances of creation we know about.
     ! (So that we can be sure that one should be the key window of the other.)
     ! We do not want to rely on anything the story has done previously, so we will create these windows ourselves and destroy them later.
     ! Windows are created by establishing a root or by splitting, depending on whether a root already exists.
     ! Therefore, test for a root.
     root = glk_window_get_root();
     if (root) {
       ! A root already exists, so we must split.
       ! Under 961, closing a window split off of the root without also closing the root can make the story invisible.
       ! Consequently, we cannot safely split the root itself.
       ! So we look for a nonroot window.
       for (nonroot = 0: nonroot = glk_window_iterate(nonroot, 0):) {
         if (nonroot ~= root) {
           break;
         }
       }
       ! If we found a window to split, the loop terminated by a break and set nonroot to that window.
       ! Otherwise nonroot is zero, from the end of the glk_window_iterate cycle.
       if (nonroot) {
         ! Since we found a window, split it.
         firstWindow = glk_window_open(nonroot, winmethod_Below | winmethod_Proportional, 50, wintype_TextBuffer, 0);
       } else {
         ! Otherwise we know that there is exactly one window open.
         ! Rather than risk bug 961, we opt to close this window and create a root.
         ! The story's Glk recovery code should be able to handle that reasonably.
         glk_window_close(root, 0);
         firstWindow = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
       }
     } else {
       ! A root does not exist, so we may create one.
       firstWindow = glk_window_open(0, 0, 0, wintype_TextBuffer, 0);
     }
     ! Root creation and window splitting may fail under some Glk implementations, but not CocoaGlk.
     ! If we saw a failure, we can skip the rest of this detection process.
     if (firstWindow) {
       ! Now there must be a root, and we are sure that firstWindow is safe to split.
       ! Split it.
       secondWindow = glk_window_open(firstWindow, winmethod_Below | winmethod_Proportional, 50, wintype_TextBuffer, 0);
       ! Again, window splitting may fail under some Glk implementations, but not CocoaGlk.
       ! If we saw a failure, we can skip the rest of this detection process, except for cleaning up the window we did create.
       if (secondWindow) {
         ! Finally, we have our two windows whose circumstances of creation we know about.
         ! We ask the Glk implementation for the key of firstWindow, expecting it to be secondWindow.
         glk_window_get_arrangement(glk_window_get_parent(firstWindow), is_cocoaMethodCheck, is_cocoaSizeCheck, is_cocoaKeyWindowCheck);
         ! If, instead, we got a result of firstWindow, that's bug 819, and we're dealing with CocoaGlk.
         (+ CocoaGlk detection flag +) = (is_cocoaKeyWindowCheck-->0) == firstWindow;
         ! Now clean up the second window.
         glk_window_close(secondWindow, 0);
       }
       ! And clean up the first window.
       glk_window_close(firstWindow, 0);
     }
     rfalse;
   ];
-).

The detect CocoaGlk rule translates into I6 as "is_detectCocoaGlk".
The detect CocoaGlk rule is listed in the resniffing rulebook.

Section "CocoaGlk Rule" (unindexed)

IO implementation detection (this is the test for CocoaGlk rule):
   if the CocoaGlk detection flag is true:
     rule succeeds with result CocoaGlk.

Book "Interpreter Tests"

FyreVM, Zoom, and Git/Gift-based interpreter are interpreters.

To decide what interpreter is the current interpreter:
   if the current IO implementation is:
     -- FyreVM channel system:
       decide on FyreVM;
     -- CocoaGlk:
       decide on Zoom; [This is potentially controversial, as the I7 Mac IDE also uses CocoaGlk.]
     -- Unknown Glk implementation:
       if the current Glulx implementation is:
         -- Git/Gift Glulx:
           decide on Git/Gift-based interpreter;
   decide on Unknown interpreter.

Interpreter Sniffing ends here.